#pragma once
//------------------------------------------------------------------------
//
//  Name:   MinerOwnedStates.h
//
//  Desc:   All the states that can be assigned to the Miner class
//
//  Author: Mat Buckland 2002 (fup@ai-junkie.com)
//
//------------------------------------------------------------------------
#include "../StateMachine/stdafx.h"
#include <boost/any.hpp>
#include "../stdafx.h"

	class FightSM;
	class FightMainLoop : public State<FightSM>
	{
	private:

		FightMainLoop(){}

		//copy ctor and assignment should be private
		FightMainLoop(const FightMainLoop&);
		FightMainLoop& operator=(const FightMainLoop&);

	public:

		static FightMainLoop* Instance();

		virtual void Enter(FightSM* miner);

		virtual void Execute(FightSM* miner);

		virtual void Exit(FightSM* miner);
		
		virtual bool OnMessage(FightSM* miner,boost::any p);

	};

	class FightMenu : public State<FightSM>
	{
	private:

		FightMenu(){}

		//copy ctor and assignment should be private
		FightMenu(const FightMenu&);
		FightMenu& operator=(const FightMenu&);

	public:

		static FightMenu* Instance();

		virtual void Enter(FightSM* miner);

		virtual void Execute(FightSM* miner);

		virtual void Exit(FightSM* miner);
		
		virtual bool OnMessage(FightSM* miner,boost::any p);
	};

	class FightAttack : public State<FightSM>
	{
	private:

		FightAttack(){}

		//copy ctor and assignment should be private
		FightAttack(const FightAttack&);
		FightAttack& operator=(const FightAttack&);

	public:

		static FightAttack* Instance();

		virtual void Enter(FightSM* miner);

		virtual void Execute(FightSM* miner);

		virtual void Exit(FightSM* miner);
		
		virtual bool OnMessage(FightSM* miner,boost::any p);
	};

	class FightMove : public State<FightSM>
	{
	private:

		FightMove(){}

		//copy ctor and assignment should be private
		FightMove(const FightMove&);
		FightMove& operator=(const FightMove&);

	public:

		static FightMove* Instance();

		virtual void Enter(FightSM* miner);

		virtual void Execute(FightSM* miner);

		virtual void Exit(FightSM* miner);
		
		virtual bool OnMessage(FightSM* miner,boost::any p);
	};

	class FightComSkill : public State<FightSM>
	{
	private:

		FightComSkill(){}

		//copy ctor and assignment should be private
		FightComSkill(const FightComSkill&);
		FightComSkill& operator=(const FightComSkill&);

	public:

		static FightComSkill* Instance();

		virtual void Enter(FightSM* miner);

		virtual void Execute(FightSM* miner);

		virtual void Exit(FightSM* miner);
		
		virtual bool OnMessage(FightSM* miner,boost::any p);
	};

	class FightMagic : public State<FightSM>
	{
	private:

		FightMagic(){}

		//copy ctor and assignment should be private
		FightMagic(const FightMagic&);
		FightMagic& operator=(const FightMagic&);

	public:

		static FightMagic* Instance();

		virtual void Enter(FightSM* miner);

		virtual void Execute(FightSM* miner);

		virtual void Exit(FightSM* miner);
		
		virtual bool OnMessage(FightSM* miner,boost::any p);
	};

	class FightGuard : public State<FightSM>
	{
	private:

		FightGuard(){}

		//copy ctor and assignment should be private
		FightGuard(const FightGuard&);
		FightGuard& operator=(const FightGuard&);

	public:

		static FightGuard* Instance();

		virtual void Enter(FightSM* miner);

		virtual void Execute(FightSM* miner);

		virtual void Exit(FightSM* miner);
		
		virtual bool OnMessage(FightSM* miner,boost::any p);
	};

	class FightProps : public State<FightSM>
	{
	private:

		FightProps(){}

		//copy ctor and assignment should be private
		FightProps(const FightProps&);
		FightProps& operator=(const FightProps&);

	public:

		static FightProps* Instance();

		virtual void Enter(FightSM* miner);

		virtual void Execute(FightSM* miner);

		virtual void Exit(FightSM* miner);
		
		virtual bool OnMessage(FightSM* miner,boost::any p);
	};